package com.hfb.mashibing.alip8.designpattern._013Iterator;

import java.util.Objects;
import lombok.Data;

/**
 * Q: 手动构建一个容器，可以添加对象
 * A: 数组实现 V1
 * A: 链表实现 V2
 * A: 数组、链表实现接口 V3
 * Q：请问如何遍历容器呢？V4
 * A: 规定一个标准迭代器，让每中容器实现自己的迭代器 V5
 *
 * Q：看看JDK的源码 V6
 * A: 追加泛型实现 V7
 *
 */
public class V7Main {

    public static void main(String[] args) {
        Collection<String> li = new ArrayList<String>();
        for (int i = 0; i < 15; i++) {
            li.add(new String("s" + i));
        }
        System.err.printf("LinkedList 的长度：%s\n", li.size());

        Iterator it = li.iterator();
        while (it.hasNext()) {
            System.out.print(it.next());
        }
        System.out.println("------");



//        Collection li = new LinkedList();
//        for (int i = 0; i < 15; i++) {
//            li.add(new String("s" + i));
//        }
//        System.err.printf("LinkedList 的长度：%s\n", li.size());
//
//        Iterator it = li.iterator();
//        while (it.hasNext()) {
//            System.out.print(it.next());
//        }
//        System.out.println();
    }

    interface Collection<T> {
        void add(T t);
        int size();
        Iterator iterator();
    }
    interface Iterator<T> {
        boolean hasNext();
        T next();

    }
    /**
     * 相比数组，此容器不用考虑边界问题，可以动态扩展
     */
    static class ArrayList<T> implements Collection<T> {
        T[] objects = (T[]) new Object[10];
        /*
         *   objects 中下一个空位置在哪儿，or 目前容器中有多少个元素
         */
        private int index = 0;   // 冗余数据

        @Override
        public void add(T o) {
            if (index == objects.length) {
                T[] newObjects = (T[]) new Object[objects.length*2];
                System.arraycopy(objects, 0, newObjects, 0, objects.length);
                objects = newObjects;
            }
            objects[index] = o;
            index ++;
        }
        @Override
        public int size(){
            return index;
        }

        @Override
        public Iterator<T> iterator() {
            return new ArrayListIterator<T>();
        }
        private class ArrayListIterator<T> implements Iterator<T> {
            // 当前循环到第几个了？
            private int currentIndex = 0;

            @Override
            public boolean hasNext() {
                return currentIndex >= index ? false : true;
            }

            @Override
            public T next() {
                T t = (T) objects[currentIndex];
                currentIndex ++;
                return t;
            }
        }
    }

    /**
     * 相比数组，此容器不用考虑边界问题，可以动态扩展
     */
    static class LinkedList<T> implements Collection<T> {
        Node head = null;
        Node tail = null;   // 冗余数据
        /*
         *   objects 中下一个空位置在哪儿，or 目前容器中有多少个元素
         */
        private int size = 0;   // 冗余数据
        @Override
        public void add(T o) {
            Node n = new Node(o);
            n.next = null;
            if(Objects.isNull(head)){
                head = n;
                tail = n;
            }
            tail.next = n;
            tail = n;
            size ++;
        }
        @Override
        public int size(){
            return size;
        }

        @Override
        public Iterator<T> iterator() {
            return new Iterator() {
                private Node currentNode = null;
                @Override
                public boolean hasNext() {
                    currentNode = head;
                    return currentNode.next != null;
                }

                @Override
                public T next() {
                    currentNode = currentNode.next;
                    return (T) currentNode.getO();
                }
            };
        }
        @Data
        class Node{
            private Object o; // 存放数据
            Node next;  // 指向下个节点的指针

            public Node(Object o) {
                this.o = o;
            }
        }
    }
}
